#include "Annuaire.h"

/*Constructeur*/

void AnnuaireInit(Annuaire* A)
{

  A->indiceLecture=0;
  A->indiceEcriture=0;
 
  fabricantInit(&(A->f),(char*) "fabricant.txt");
 
  const char* port="2222";
  A->s.demarrer(port);
  
  /* Initialize mutex and condition variable objects */
  pthread_mutex_init(&(A->mutex_ATraiter), NULL);
  pthread_cond_init (&(A->ATraiter_pleine), NULL);
  pthread_cond_init (&(A->ATraiter_vide), NULL);

}

/*Accesseurs*/
Fabricant* getFabricant(Annuaire* a)
{
  return &(a->f);
}
/*Mutateur*/
void SetFabricant(Annuaire* a,Fabricant* fab)
{
  a->f=*fab;
}


/* Opérateurs */

/*Methodes*/
Message get(Annuaire* A,int t){
  Message m;
  pthread_mutex_lock(&(A->mutex_ATraiter));
  printf("Ouvrier %d : je viens de locker le mutex\n",t);
  while(A->indiceLecture==A->indiceEcriture)
    {
      printf("Ouvrier %d : Le tableau est vide\n",t);
      printf("Ouvrier %d : je me met en attente\n",t);
      pthread_cond_wait(&A->ATraiter_vide,&(A->mutex_ATraiter));
    }

  //recuperation du prochain message a traiter
  m=A->aTraiter[A->indiceLecture];
  A->indiceLecture++;
  printf("Ouvrier %d : j'ai récupéré un message\n",t);

  if(A->indiceLecture>=MESSAGE_SIZE)
    A->indiceLecture=0;
  pthread_cond_signal(&A->ATraiter_pleine);
  printf("Ouvrier %d : je vais délocker le mutex\n",t);
  pthread_mutex_unlock(&A->mutex_ATraiter);
  return m;
}

void put(Annuaire* A,Message m) {
  pthread_mutex_lock(&(A->mutex_ATraiter));
  printf("Manager : je viens de locker le mutex\n");
  while((A->indiceEcriture+1)%MESSAGE_SIZE==A->indiceLecture) {
    printf("Le tableau est plein : un message est ignoré");
    pthread_cond_wait(&A->ATraiter_pleine,&(A->mutex_ATraiter));
  }
  A->aTraiter[A->indiceEcriture]=m;
  A->indiceEcriture++;
  if(A->indiceEcriture>=MESSAGE_SIZE)
    A->indiceEcriture=0;
  pthread_cond_broadcast(&A->ATraiter_vide);
  printf("Manager: je vais délocker le mutex\n");
  pthread_mutex_unlock(&A->mutex_ATraiter);
}
